{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fdb9242f-cc3f-41ee-a45a-0a3d02d714b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from sklearn.metrics import f1_score\n",
    "from sklearn.manifold import TSNE\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "from dgl.nn.pytorch import GATConv\n",
    "import datetime\n",
    "import dgl\n",
    "import errno\n",
    "import numpy as np\n",
    "import os\n",
    "import pickle\n",
    "import random\n",
    "import torch\n",
    "from dgl.data.utils import download, get_download_dir, _get_dgl_url\n",
    "from scipy import sparse\n",
    "from scipy import io as sio\n",
    "\n",
    "import warnings\n",
    "\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b62db07e-de28-4220-8296-bd9bba4ddd69",
   "metadata": {},
   "outputs": [],
   "source": [
    "# utils\n",
    "def get_binary_mask(total_size, indices):\n",
    "    mask = torch.zeros(total_size)\n",
    "    mask[indices] = 1\n",
    "    return mask.byte()\n",
    "\n",
    "def load_acm(remove_self_loop):\n",
    "    url = 'dataset/ACM3025.pkl'\n",
    "    data_path = get_download_dir() + '/ACM3025.pkl'\n",
    "    download(_get_dgl_url(url), path=data_path)\n",
    "\n",
    "    with open(data_path, 'rb') as f:\n",
    "        data = pickle.load(f)\n",
    "\n",
    "    labels, features = torch.from_numpy(data['label'].todense()).long(), \\\n",
    "                       torch.from_numpy(data['feature'].todense()).float()\n",
    "    num_classes = labels.shape[1]\n",
    "    labels = labels.nonzero()[:, 1]\n",
    "\n",
    "    if remove_self_loop:\n",
    "        num_nodes = data['label'].shape[0]\n",
    "        data['PAP'] = sparse.csr_matrix(data['PAP'] - np.eye(num_nodes))\n",
    "        data['PLP'] = sparse.csr_matrix(data['PLP'] - np.eye(num_nodes))\n",
    "\n",
    "    # Adjacency matrices for meta path based neighbors\n",
    "    # (Mufei): I verified both of them are binary adjacency matrices with self loops\n",
    "    author_g = dgl.from_scipy(data['PAP'])\n",
    "    subject_g = dgl.from_scipy(data['PLP'])\n",
    "    gs = [author_g, subject_g]\n",
    "\n",
    "    train_idx = torch.from_numpy(data['train_idx']).long().squeeze(0)\n",
    "    val_idx = torch.from_numpy(data['val_idx']).long().squeeze(0)\n",
    "    test_idx = torch.from_numpy(data['test_idx']).long().squeeze(0)\n",
    "\n",
    "    num_nodes = author_g.number_of_nodes()\n",
    "    train_mask = get_binary_mask(num_nodes, train_idx)\n",
    "    val_mask = get_binary_mask(num_nodes, val_idx)\n",
    "    test_mask = get_binary_mask(num_nodes, test_idx)\n",
    "\n",
    "    print('dataset loaded')\n",
    "    print({\n",
    "        'dataset': 'ACM',\n",
    "        'train': train_mask.sum().item() / num_nodes,\n",
    "        'val': val_mask.sum().item() / num_nodes,\n",
    "        'test': test_mask.sum().item() / num_nodes\n",
    "    })\n",
    "\n",
    "    return gs, features, labels, num_classes, train_idx, val_idx, test_idx, \\\n",
    "           train_mask, val_mask, test_mask\n",
    "\n",
    "def load_acm_raw(remove_self_loop):\n",
    "    assert not remove_self_loop\n",
    "    url = 'dataset/ACM.mat'\n",
    "    data_path = get_download_dir() + '/ACM.mat'\n",
    "    download(_get_dgl_url(url), path=data_path)\n",
    "\n",
    "    data = sio.loadmat(data_path)\n",
    "    p_vs_l = data['PvsL']       # paper-field?\n",
    "    p_vs_a = data['PvsA']       # paper-author\n",
    "    p_vs_t = data['PvsT']       # paper-term, bag of words\n",
    "    p_vs_c = data['PvsC']       # paper-conference, labels come from that\n",
    "\n",
    "    # We assign\n",
    "    # (1) KDD papers as class 0 (data mining),\n",
    "    # (2) SIGMOD and VLDB papers as class 1 (database),\n",
    "    # (3) SIGCOMM and MOBICOMM papers as class 2 (communication)\n",
    "    conf_ids = [0, 1, 9, 10, 13]\n",
    "    label_ids = [0, 1, 2, 2, 1]\n",
    "\n",
    "    p_vs_c_filter = p_vs_c[:, conf_ids]\n",
    "    p_selected = (p_vs_c_filter.sum(1) != 0).A1.nonzero()[0]\n",
    "    p_vs_l = p_vs_l[p_selected]\n",
    "    p_vs_a = p_vs_a[p_selected]\n",
    "    p_vs_t = p_vs_t[p_selected]\n",
    "    p_vs_c = p_vs_c[p_selected]\n",
    "\n",
    "    hg = dgl.heterograph({\n",
    "        ('paper', 'pa', 'author'): p_vs_a.nonzero(),\n",
    "        ('author', 'ap', 'paper'): p_vs_a.transpose().nonzero(),\n",
    "        ('paper', 'pf', 'field'): p_vs_l.nonzero(),\n",
    "        ('field', 'fp', 'paper'): p_vs_l.transpose().nonzero()\n",
    "    })\n",
    "\n",
    "    features = torch.FloatTensor(p_vs_t.toarray())\n",
    "\n",
    "    pc_p, pc_c = p_vs_c.nonzero()\n",
    "    labels = np.zeros(len(p_selected), dtype=np.int64)\n",
    "    for conf_id, label_id in zip(conf_ids, label_ids):\n",
    "        labels[pc_p[pc_c == conf_id]] = label_id\n",
    "    labels = torch.LongTensor(labels)\n",
    "\n",
    "    num_classes = 3\n",
    "\n",
    "    float_mask = np.zeros(len(pc_p))\n",
    "    for conf_id in conf_ids:\n",
    "        pc_c_mask = (pc_c == conf_id)\n",
    "        float_mask[pc_c_mask] = np.random.permutation(np.linspace(0, 1, pc_c_mask.sum()))\n",
    "    train_idx = np.where(float_mask <= 0.2)[0]\n",
    "    val_idx = np.where((float_mask > 0.2) & (float_mask <= 0.3))[0]\n",
    "    test_idx = np.where(float_mask > 0.3)[0]\n",
    "\n",
    "    num_nodes = hg.number_of_nodes('paper')\n",
    "    train_mask = get_binary_mask(num_nodes, train_idx)\n",
    "    val_mask = get_binary_mask(num_nodes, val_idx)\n",
    "    test_mask = get_binary_mask(num_nodes, test_idx)\n",
    "\n",
    "    return hg, features, labels, num_classes, train_idx, val_idx, test_idx, \\\n",
    "            train_mask, val_mask, test_mask\n",
    "\n",
    "def load_data(dataset, remove_self_loop=False):\n",
    "    if dataset == 'ACM':\n",
    "        return load_acm(remove_self_loop)\n",
    "    elif dataset == 'ACMRaw':\n",
    "        return load_acm_raw(remove_self_loop)\n",
    "    else:\n",
    "        return NotImplementedError('Unsupported dataset {}'.format(dataset))\n",
    "\n",
    "class EarlyStopping(object):\n",
    "    def __init__(self, patience=10):\n",
    "        dt = datetime.datetime.now()\n",
    "        self.filename = 'early_stop_{}_{:02d}-{:02d}-{:02d}.pth'.format(\n",
    "            dt.date(), dt.hour, dt.minute, dt.second)\n",
    "        self.patience = patience\n",
    "        self.counter = 0\n",
    "        self.best_acc = None\n",
    "        self.best_loss = None\n",
    "        self.early_stop = False\n",
    "\n",
    "    def step(self, loss, acc, model):\n",
    "        if self.best_loss is None:\n",
    "            self.best_acc = acc\n",
    "            self.best_loss = loss\n",
    "            self.save_checkpoint(model)\n",
    "        elif (loss > self.best_loss) and (acc < self.best_acc):\n",
    "            self.counter += 1\n",
    "            print(f'EarlyStopping counter: {self.counter} out of {self.patience}')\n",
    "            if self.counter >= self.patience:\n",
    "                self.early_stop = True\n",
    "        else:\n",
    "            if (loss <= self.best_loss) and (acc >= self.best_acc):\n",
    "                self.save_checkpoint(model)\n",
    "            self.best_loss = np.min((loss, self.best_loss))\n",
    "            self.best_acc = np.max((acc, self.best_acc))\n",
    "            self.counter = 0\n",
    "        return self.early_stop\n",
    "\n",
    "    def save_checkpoint(self, model):\n",
    "        \"\"\"Saves model when validation loss decreases.\"\"\"\n",
    "        torch.save(model.state_dict(), self.filename)\n",
    "\n",
    "    def load_checkpoint(self, model):\n",
    "        \"\"\"Load the latest checkpoint.\"\"\"\n",
    "        model.load_state_dict(torch.load(self.filename))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0058d09b-2abe-4fc9-a2ab-c2326aab6162",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 模型\n",
    "class SemanticAttention(nn.Module):\n",
    "    def __init__(self, in_size, hidden_size=128):\n",
    "        super(SemanticAttention, self).__init__()\n",
    "\n",
    "        self.project = nn.Sequential(\n",
    "            nn.Linear(in_size, hidden_size),\n",
    "            nn.Tanh(),\n",
    "            nn.Linear(hidden_size, 1, bias=False)\n",
    "        )\n",
    "\n",
    "    def forward(self, z):\n",
    "        w = self.project(z).mean(0)                    # (M, 1)\n",
    "        beta = torch.softmax(w, dim=0)                 # (M, 1)\n",
    "        beta = beta.expand((z.shape[0],) + beta.shape) # (N, M, 1)\n",
    "\n",
    "        return (beta * z).sum(1)                       # (N, D * K)\n",
    "\n",
    "class HANLayer(nn.Module):\n",
    "    \"\"\"\n",
    "    HAN layer.\n",
    "\n",
    "    Arguments\n",
    "    ---------\n",
    "    num_meta_paths : number of homogeneous graphs generated from the metapaths.\n",
    "    in_size : input feature dimension\n",
    "    out_size : output feature dimension\n",
    "    layer_num_heads : number of attention heads\n",
    "    dropout : Dropout probability\n",
    "\n",
    "    Inputs\n",
    "    ------\n",
    "    g : list[DGLGraph]\n",
    "        List of graphs\n",
    "    h : tensor\n",
    "        Input features\n",
    "\n",
    "    Outputs\n",
    "    -------\n",
    "    tensor\n",
    "        The output feature\n",
    "    \"\"\"\n",
    "    def __init__(self, num_meta_paths, in_size, out_size, layer_num_heads, dropout):\n",
    "        super(HANLayer, self).__init__()\n",
    "\n",
    "        # One GAT layer for each meta path based adjacency matrix\n",
    "        self.gat_layers = nn.ModuleList()\n",
    "        for i in range(num_meta_paths):\n",
    "            self.gat_layers.append(GATConv(in_size, out_size, layer_num_heads,\n",
    "                                           dropout, dropout, activation=F.elu))\n",
    "        self.semantic_attention = SemanticAttention(in_size=out_size * layer_num_heads)\n",
    "        self.num_meta_paths = num_meta_paths\n",
    "\n",
    "    def forward(self, gs, h):\n",
    "        semantic_embeddings = []\n",
    "\n",
    "        for i, g in enumerate(gs):\n",
    "            semantic_embeddings.append(self.gat_layers[i](g, h).flatten(1))\n",
    "        semantic_embeddings = torch.stack(semantic_embeddings, dim=1)                  # (N, M, D * K)\n",
    "\n",
    "        return self.semantic_attention(semantic_embeddings)                            # (N, D * K)\n",
    "\n",
    "class HAN(nn.Module):\n",
    "    def __init__(self, num_meta_paths, in_size, hidden_size, out_size, num_heads, dropout):\n",
    "        super(HAN, self).__init__()\n",
    "\n",
    "        self.layers = nn.ModuleList()\n",
    "        self.layers.append(HANLayer(num_meta_paths, in_size, hidden_size, num_heads[0], dropout))\n",
    "        for l in range(1, len(num_heads)):\n",
    "            self.layers.append(HANLayer(num_meta_paths, hidden_size * num_heads[l-1],\n",
    "                                        hidden_size, num_heads[l], dropout))\n",
    "        self.predict = nn.Linear(hidden_size * num_heads[-1], out_size)\n",
    "\n",
    "    def forward(self, g, h, is_training=True):\n",
    "        for gnn in self.layers:\n",
    "            h = gnn(g, h)\n",
    "            \n",
    "        if is_training:\n",
    "            return self.predict(h)\n",
    "        else:\n",
    "            return h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "247c9f49-7261-4c62-83a1-ee8937580300",
   "metadata": {},
   "outputs": [],
   "source": [
    "def score(logits, labels):\n",
    "    _, indices = torch.max(logits, dim=1)\n",
    "    prediction = indices.long().cpu().numpy()\n",
    "    labels = labels.cpu().numpy()\n",
    "\n",
    "    accuracy = (prediction == labels).sum() / len(prediction)\n",
    "    micro_f1 = f1_score(labels, prediction, average='micro')\n",
    "    macro_f1 = f1_score(labels, prediction, average='macro')\n",
    "\n",
    "    return accuracy, micro_f1, macro_f1\n",
    "\n",
    "def evaluate(model, g, features, labels, mask, loss_func):\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        logits = model(g, features)\n",
    "    loss = loss_func(logits[mask], labels[mask])\n",
    "    accuracy, micro_f1, macro_f1 = score(logits[mask], labels[mask])\n",
    "\n",
    "    return loss, accuracy, micro_f1, macro_f1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "fb949175-5937-423c-943b-d8e875cd85f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading /Users/wangkai/.dgl/ACM3025.pkl from https://data.dgl.ai/dataset/ACM3025.pkl...\n",
      "dataset loaded\n",
      "{'dataset': 'ACM', 'train': 0.19834710743801653, 'val': 0.09917355371900827, 'test': 0.7024793388429752}\n"
     ]
    }
   ],
   "source": [
    "device = torch.device('cpu')\n",
    "g, features, labels, num_classes, train_idx, val_idx, test_idx, train_mask, \\\n",
    "    val_mask, test_mask = load_data('ACM')\n",
    "if hasattr(torch, 'BoolTensor'):\n",
    "    train_mask = train_mask.bool()\n",
    "    val_mask = val_mask.bool()\n",
    "    test_mask = test_mask.bool()\n",
    "\n",
    "features = features.to(device)\n",
    "labels = labels.to(device)\n",
    "train_mask = train_mask.to(device)\n",
    "val_mask = val_mask.to(device)\n",
    "test_mask = test_mask.to(device)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ec3b3d7b-cdc5-4335-b205-fac5282dd38f",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = HAN(num_meta_paths=len(g),\n",
    "            in_size=features.shape[1],\n",
    "            hidden_size=8,\n",
    "            out_size=num_classes,\n",
    "            num_heads=[8],\n",
    "            dropout=0.6).to(device)\n",
    "g = [graph.to(device) for graph in g]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0c47497c-c74d-4d72-87cc-7a8cc897317c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 | Train Loss 0.0378 | Train Micro f1 0.9883 | Train Macro f1 0.9883 | Val Loss 0.1730 | Val Micro f1 0.9333 | Val Macro f1 0.9330\n",
      "EarlyStopping counter: 1 out of 10\n",
      "Epoch 2 | Train Loss 0.1600 | Train Micro f1 0.9433 | Train Macro f1 0.9425 | Val Loss 0.2286 | Val Micro f1 0.9267 | Val Macro f1 0.9260\n",
      "EarlyStopping counter: 2 out of 10\n",
      "Epoch 3 | Train Loss 0.0654 | Train Micro f1 0.9800 | Train Macro f1 0.9800 | Val Loss 0.3829 | Val Micro f1 0.9000 | Val Macro f1 0.9009\n",
      "EarlyStopping counter: 3 out of 10\n",
      "Epoch 4 | Train Loss 0.1414 | Train Micro f1 0.9533 | Train Macro f1 0.9537 | Val Loss 0.2601 | Val Micro f1 0.9300 | Val Macro f1 0.9299\n",
      "Epoch 5 | Train Loss 0.0826 | Train Micro f1 0.9717 | Train Macro f1 0.9717 | Val Loss 0.1559 | Val Micro f1 0.9533 | Val Macro f1 0.9531\n",
      "Epoch 6 | Train Loss 0.0420 | Train Micro f1 0.9867 | Train Macro f1 0.9867 | Val Loss 0.1297 | Val Micro f1 0.9600 | Val Macro f1 0.9600\n",
      "EarlyStopping counter: 1 out of 10\n",
      "Epoch 7 | Train Loss 0.0399 | Train Micro f1 0.9833 | Train Macro f1 0.9833 | Val Loss 0.1431 | Val Micro f1 0.9533 | Val Macro f1 0.9534\n",
      "EarlyStopping counter: 2 out of 10\n",
      "Epoch 8 | Train Loss 0.0857 | Train Micro f1 0.9783 | Train Macro f1 0.9784 | Val Loss 0.1437 | Val Micro f1 0.9467 | Val Macro f1 0.9467\n",
      "Epoch 9 | Train Loss 0.0939 | Train Micro f1 0.9717 | Train Macro f1 0.9716 | Val Loss 0.1213 | Val Micro f1 0.9500 | Val Macro f1 0.9500\n",
      "EarlyStopping counter: 1 out of 10\n",
      "Epoch 10 | Train Loss 0.0505 | Train Micro f1 0.9817 | Train Macro f1 0.9817 | Val Loss 0.1252 | Val Micro f1 0.9533 | Val Macro f1 0.9529\n",
      "EarlyStopping counter: 2 out of 10\n",
      "Epoch 11 | Train Loss 0.0300 | Train Micro f1 0.9917 | Train Macro f1 0.9917 | Val Loss 0.1808 | Val Micro f1 0.9400 | Val Macro f1 0.9399\n",
      "EarlyStopping counter: 3 out of 10\n",
      "Epoch 12 | Train Loss 0.0642 | Train Micro f1 0.9733 | Train Macro f1 0.9734 | Val Loss 0.1677 | Val Micro f1 0.9467 | Val Macro f1 0.9463\n",
      "EarlyStopping counter: 4 out of 10\n",
      "Epoch 13 | Train Loss 0.0376 | Train Micro f1 0.9850 | Train Macro f1 0.9850 | Val Loss 0.1716 | Val Micro f1 0.9467 | Val Macro f1 0.9463\n",
      "EarlyStopping counter: 5 out of 10\n",
      "Epoch 14 | Train Loss 0.0402 | Train Micro f1 0.9867 | Train Macro f1 0.9866 | Val Loss 0.1712 | Val Micro f1 0.9500 | Val Macro f1 0.9497\n",
      "EarlyStopping counter: 6 out of 10\n",
      "Epoch 15 | Train Loss 0.0453 | Train Micro f1 0.9800 | Train Macro f1 0.9800 | Val Loss 0.1746 | Val Micro f1 0.9500 | Val Macro f1 0.9497\n",
      "EarlyStopping counter: 7 out of 10\n",
      "Epoch 16 | Train Loss 0.0431 | Train Micro f1 0.9867 | Train Macro f1 0.9867 | Val Loss 0.1755 | Val Micro f1 0.9500 | Val Macro f1 0.9497\n",
      "EarlyStopping counter: 8 out of 10\n",
      "Epoch 17 | Train Loss 0.0347 | Train Micro f1 0.9833 | Train Macro f1 0.9834 | Val Loss 0.1751 | Val Micro f1 0.9567 | Val Macro f1 0.9564\n",
      "EarlyStopping counter: 9 out of 10\n",
      "Epoch 18 | Train Loss 0.0465 | Train Micro f1 0.9817 | Train Macro f1 0.9817 | Val Loss 0.1736 | Val Micro f1 0.9567 | Val Macro f1 0.9564\n",
      "EarlyStopping counter: 10 out of 10\n",
      "Epoch 19 | Train Loss 0.0397 | Train Micro f1 0.9883 | Train Macro f1 0.9883 | Val Loss 0.1656 | Val Micro f1 0.9567 | Val Macro f1 0.9564\n",
      "Test loss 0.5502 | Test Micro f1 0.8442 | Test Macro f1 0.8431\n"
     ]
    }
   ],
   "source": [
    "stopper = EarlyStopping(patience=10)\n",
    "loss_fcn = torch.nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.005,\n",
    "                             weight_decay=0.001)\n",
    "\n",
    "for epoch in range(500):\n",
    "    model.train()\n",
    "    logits = model(g, features)\n",
    "    loss = loss_fcn(logits[train_mask], labels[train_mask])\n",
    "\n",
    "    optimizer.zero_grad()\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "\n",
    "    train_acc, train_micro_f1, train_macro_f1 = score(logits[train_mask], labels[train_mask])\n",
    "    val_loss, val_acc, val_micro_f1, val_macro_f1 = evaluate(model, g, features, labels, val_mask, loss_fcn)\n",
    "    early_stop = stopper.step(val_loss.data.item(), val_acc, model)\n",
    "\n",
    "    print('Epoch {:d} | Train Loss {:.4f} | Train Micro f1 {:.4f} | Train Macro f1 {:.4f} | '\n",
    "          'Val Loss {:.4f} | Val Micro f1 {:.4f} | Val Macro f1 {:.4f}'.format(\n",
    "        epoch + 1, loss.item(), train_micro_f1, train_macro_f1, val_loss.item(), val_micro_f1, val_macro_f1))\n",
    "\n",
    "    if early_stop:\n",
    "        break\n",
    "\n",
    "stopper.load_checkpoint(model)\n",
    "test_loss, test_acc, test_micro_f1, test_macro_f1 = evaluate(model, g, features, labels, test_mask, loss_fcn)\n",
    "print('Test loss {:.4f} | Test Micro f1 {:.4f} | Test Macro f1 {:.4f}'.format(\n",
    "    test_loss.item(), test_micro_f1, test_macro_f1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "36249b53-813d-444d-a411-cf664721932b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1280x960 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_embeddings(embeddings, X, Y):\n",
    "\n",
    "    emb_list = []\n",
    "    for k in X:\n",
    "        emb_list.append(embeddings[k])\n",
    "    emb_list = np.array(emb_list)\n",
    "\n",
    "    model = TSNE(n_components=2) ### 降维\n",
    "    node_pos = model.fit_transform(emb_list)\n",
    "\n",
    "    color_idx = {}\n",
    "    for i in range(len(X)):\n",
    "        color_idx.setdefault(Y[i], [])\n",
    "        color_idx[Y[i]].append(i)\n",
    "    plt.figure(dpi=200)\n",
    "    for c, idx in color_idx.items():\n",
    "        plt.scatter(node_pos[idx, 0], node_pos[idx, 1], label=c)\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "embedding_weights = model(g, features, is_training=False).detach().numpy()  ## 得到所有节点的embedding。\n",
    "\n",
    "plot_embeddings(embedding_weights, np.arange(features.size()[0]), labels.numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "750c53a9-0cab-45aa-a60b-f0f12d35819c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
